8bc128ed4997a468d1ed4bd977b927d0ab9f26d6,src/org/jgroups/protocols/pbcast/NAKACK.java,NAKACK,handleMessage,#Message#NakAckHeader#,737

Before Change


                //msg_to_deliver.removeHeader(getName());
                up_prot.up(new Event(Event.MSG, msg_to_deliver));
            }
            if(added) {
                // We keep track of regular messages that we added, but couldn't remove (because of ordering).
                // When we have such messages pending, then even OOB threads will remove and process them
                // http://jira.jboss.com/jira/browse/JGRP-781
                if(removed_regular_msgs == 0) {
                    undelivered_msgs.incrementAndGet();
                }
                else if(removed_regular_msgs > 1) {
                    undelivered_msgs.addAndGet(-(removed_regular_msgs -1));
                }
            }
        }

After Change


        }

        boolean loopback=local_addr.equals(sender);
        boolean added=loopback || win.add(hdr.seqno, msg);
        boolean regular_msg_added=added && !msg.isFlagSet(Message.OOB);

        // message is passed up if OOB. Later, when remove() is called, we discard it. This affects ordering !
        // http://jira.jboss.com/jira/browse/JGRP-379
        if(added && msg.isFlagSet(Message.OOB)) {
            if(!loopback || oob_loopback_msgs.remove(hdr.seqno)) {
                up_prot.up(new Event(Event.MSG, msg));
                win.removeOOBMessage();
                if(!(win.hasMessagesToRemove() && undelivered_msgs.get() > 0))
                    return;
            }
        }

        // Prevents concurrent passing up of messages by different threads (http://jira.jboss.com/jira/browse/JGRP-198);
        // this is all the more important once we have a threadless stack (http://jira.jboss.com/jira/browse/JGRP-181),
        // where lots of threads can come up to this point concurrently, but only 1 is allowed to pass at a time
        // We *can* deliver messages from *different* senders concurrently, e.g. reception of P1, Q1, P2, Q2 can result in
        // delivery of P1, Q1, Q2, P2: FIFO (implemented by NAKACK) says messages need to be delivered in the
        // order in which they were sent by the sender
        Message msg_to_deliver;
        ReentrantLock lock=win.getLock();
        lock.lock();
        try {
            if(eager_lock_release)
                locks.put(Thread.currentThread(), lock);
            short removed_regular_msgs=0;
            while((msg_to_deliver=win.remove()) != null) {

                // discard OOB msg as it has already been delivered (http://jira.jboss.com/jira/browse/JGRP-379)
                if(msg_to_deliver.isFlagSet(Message.OOB)) {
                    continue;
                }
                removed_regular_msgs++;

                // Changed by bela Jan 29 2003: not needed (see above)
                //msg_to_deliver.removeHeader(getName());
                up_prot.up(new Event(Event.MSG, msg_to_deliver));
            }

            // We keep track of regular messages that we added, but couldn't remove (because of ordering).
            // When we have such messages pending, then even OOB threads will remove and process them
            // http://jira.jboss.com/jira/browse/JGRP-781
            if(regular_msg_added && removed_regular_msgs == 0) {
                undelivered_msgs.incrementAndGet();
            }
            if(removed_regular_msgs > 0) { // regardless of whether a message was added or not !
                int num_msgs_added=regular_msg_added? 1 : 0;
                undelivered_msgs.addAndGet(-(removed_regular_msgs -num_msgs_added));
            }
        }
        finally {